/**
 * 
 */
package es.uned.eped.tad.lineales.ejercicios;

import es.uned.eped.tad.interfaces.IteratorIF;
import es.uned.eped.tad.interfaces.*;
import es.uned.eped.tad.lineales.ListDynamic;


/**
 * @author Paloma
 * @param <T>
 *
 */
public class Tema08Pilas<T> {

	/**
	 *  Hacerlo iterativamente ya que si se hace recursivamente al hacer el pop destruye el elemento y luego hay que reconstruirlo 
	 * @param <T>
	 * @param <T>
	 * @return
	 */
	public   ListIF<T> toList(StackIF<T> s)
	{
		ListIF<T> r = new ListDynamic<T>();
		IteratorIF<T> it = s.getIterator();
				while(it.hasNext()){
					r.insert(it.getNext());
				}
	return r;
	} 
	
	/** 
	 * Elemto base, 
	 * 
	 */
	
	public T base (StackIF<T> s ){
		if(s.getLength() == 1) return s.getTop();
		else {
			T e = s.getTop();
			s.pop();
			T r = base(s);
			s.push(e);
			return r;
		}

	}
	
	/** insertar en la base 
	 * 
	 */
	public StackIF<T> insert (StackIF<T> s, T e ){
		if(s.isEmpty()) return s.push(e);
		else {
			T el = s.getTop();
			s.pop();
			return insert(s,e).push(el);
		}

	}
/**
 * Inverir pila
 * 
 */
	
	public StackIF<T> inverse (StackIF<T> s ){
		IteratorIF<T> it = s.getIterator();
		StackIF<T> r = new StackDynamic<T>();
		while(it.hasNext()){
			r.push(it.getNext();
		)
		return r;
		}
		
		/**
		 * Inverir pila recursiva
		 * 
		 */
		
			public StackIF<T> inverse11 (StackIF<T> s, StackIF<T> r ){

				if(s.isEmpty()) return r;
				else{
					T e = s.getTop();		// cima de la  pila 
					s.pop();                 
					StackIF<T> is= inverse1(s, r.push(e));
					s.push(e);
				)
				return is;
				}

		
	} 
	Ejercicios: 
			Conjuntos, 
			inversion con iteradores 
			torres de hanoi --> traspasar las pilas sin poner una menor sobre una mayor complejidad = 2l con 23 discos no es resoluble  
			
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
